﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Forms;
using System.Collections;
using System.ComponentModel;
using System.IO;
using System.Windows.Markup;
using System.Xml;
using System.Xml.Serialization;

namespace editor
{
    /// <summary>
    /// Логика взаимодействия для MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        int tekuhee_load=-1, count_save=0;   //текущие загружаемый файл номерр сохранения
        //декоратор
        AdornerLayer layer;
        //номер в канвасе
        public int n_child;
        // есть декоратор 
        private bool pont_adorner;
        private strelka_ adorner;
        String save_undo_rendo = "./save_undo_redo/strn";



        System.Drawing.Size s;

        List<life_time> list_life_time;
        List<System.Windows.Controls.TextBox> list_text_box;//////////////////////////////////
        List<line_strelk> list_strelka;
        
        life_time a;
        life_time A1;
        Point p;
        bool createshapes;
        bool twopoint;
        public MainWindow()
        {
            InitializeComponent();

            list_strelka=new List<line_strelk>();
        
            list_life_time = new List<life_time>();
        }

        //рисование линии
        Line lineshapes;

        Line sde;
        //линия связи
        line_strelk li_;
        
       

        //линия жизни
        life_time life_t;

        //отображает комент
        System.Windows.Controls.TextBox tew; 
   
        Ellipse ellip;

        private bool redacto;

        //рисование линий
        private  int numb=1;

        private bool scal;

        private bool controlmove;
        //удаление
        private bool Remove;

        //перетаскивание линии жизни
        private bool life_time_capture;
        private bool life_time_capture_no;

        //перетаскивание фигуры
        private bool fiure;


        private bool linr_;
        private double x2;
        private double x1, zoom=1;


        private bool point_x1;


        //рисование стрелки
        private bool str_asinh;
        private double X_F;

        //начальная позиция для рисование стрелки и линии времени 
        private double X_0;   
     
        //координата y для второой линии жизни
        private double rect_2_Y;   
        private double line_Y2;
        //событие с возвратом
        private bool event_return;     
 


        private void crete_Click(object sender, RoutedEventArgs e)
        {
            createshapes = true;
            Rectangle rect1 = new Rectangle();
            rect1.Height = rect1.Width = 32;
            rect1.Fill = Brushes.Blue;
            Canvas.SetTop(rect1, 30);
            Canvas.SetLeft(rect1, 30);
            canvas1.Children.Add(rect1);
        }
        private void canvas1_MouseDown(object sender, MouseButtonEventArgs e)
        {
              // lineshapes.X2 = e.GetPosition(canvas1).X;
              //lineshapes.Y2 = e.GetPosition(canvas1).Y;
        }
        private void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (redacto == true)
            {
                Remove=false;
                lineshapes.X2 = e.GetPosition(canvas1).X;
                lineshapes.Y2 = e.GetPosition(canvas1).Y;
                redacto = false;
            }
            if (line.IsChecked == true)
            {
                Remove=false;
                if (numb == 1)
                {
                    numb--;

                    lineshapes = new Line();
                    lineshapes.X1 = e.GetPosition(canvas1).X;
                    lineshapes.Y1 = e.GetPosition(canvas1).Y;

                    lineshapes.StrokeEndLineCap = PenLineCap.Triangle;  //задает наконечник
                    lineshapes.Stroke = Brushes.Black;                   //способ закраски контура fill не исполь solicolorbrash

                    lineshapes.StrokeMiterLimit = 10;
                    DoubleCollection D_C_l =new DoubleCollection(2);
                    D_C_l.Add(4);
                    D_C_l.Add(2);
                    lineshapes.StrokeDashArray= D_C_l;                  //задает пунктир
                    lineshapes.StrokeThickness = 2;                    //задает толщину
                }
                else
                {
                    numb = 1;

                    lineshapes.X2 = e.GetPosition(canvas1).X;
                    lineshapes.Y2 = e.GetPosition(canvas1).Y;
                    //layer = AdornerLayer.GetAdornerLayer(lineshapes);
                    //adorner = new strelka_(lineshapes);
                    //layer.Add(adorner);
                   // pont_adorner = true;


                    //lineshapes.MouseEnter+=new System.Windows.Input.MouseEventHandler(lineshapes_MouseEnter);
                    //this.button1.Click += new System.EventHandler(this.button1_Click);
                    canvas1.Children.Add(lineshapes);
                }
            }
            //рисование стрелки 
            if (li_str.IsChecked == true)
            {
                //str_asinhr A_s = new str_asinhr();
                //Canvas.SetTop(A_s, e.GetPosition(canvas1).Y);
                //Canvas.SetLeft(A_s, e.GetPosition(canvas1).X);
                str_asinh = true;
            }
            //if (share.IsChecked == true)
            //{
            //    Remove=false;

            //    ellip = new Ellipse();
            //    ellip.Width = ellip.Height = 50;
            //    ellip.Stroke = Brushes.Black;       //контур
            //    ellip.Fill = Brushes.White;         //заполнение

            //    ellip.StrokeThickness = 5;    //толщина
            //    ellip.MouseEnter+=new System.Windows.Input.MouseEventHandler(ellip_MouseEnter);
            //    ellip.MouseLeave+=new System.Windows.Input.MouseEventHandler(ellip_MouseLeave);
            //    //позиция на канвасе
            //    Canvas.SetTop(ellip,e.GetPosition(canvas1).Y );
            //    Canvas.SetLeft(ellip, e.GetPosition(canvas1).X);
            //    //добавляем в коллекцию
            //    canvas1.Children.Add(ellip);
                
            //}
            if (linelife.IsChecked == true)
            {
                Remove=false;
                controlmove = false;
                life_t = new life_time();
                life_t.dro = false;

                life_t.MouseLeftButtonDown+=new MouseButtonEventHandler(life_t_MouseLeftButtonDown);
                life_t.MouseMove+=new System.Windows.Input.MouseEventHandler(life_t_MouseMove);
                //life_t.MouseLeftButtonUp+=new MouseButtonEventHandler(life_t_MouseLeftButtonUp);
                life_t.PreviewMouseDown+=new MouseButtonEventHandler(life_t_PreviewMouseDown);
                life_t.PreviewMouseLeftButtonUp+=new MouseButtonEventHandler(life_t_PreviewMouseLeftButtonUp);
              
                list_life_time.Add(life_t);
                //позиция на канвасе
                Canvas.SetTop(life_t, 20);
                Canvas.SetLeft(life_t, e.GetPosition(canvas1).X);

                life_t.n_child = canvas1.Children.Count;
                //добавляем в коллекцию
                canvas1.Children.Add(life_t);
                SaveDiagram(save_undo_rendo + count_save);
                count_save++;
                tekuhee_load++;
            }
            //если выбрана клавиша текста
            if (text.IsChecked == true)
            {
                Remove=false;

                tew = new System.Windows.Controls.TextBox ();

                tew.MouseEnter+=new System.Windows.Input.MouseEventHandler(tew_MouseEnter);
                tew.MouseLeave+=new System.Windows.Input.MouseEventHandler(tew_MouseLeave);
                //tew.MouseLeftButtonDown+=new MouseButtonEventHandler(tew_MouseLeftButtonDown);
                tew.MouseDoubleClick+=new MouseButtonEventHandler(tew_MouseDoubleClick);

                tew.MaxLength = 100;
                tew.MaxWidth = 100;
                tew.MaxHeight = 100;

                //рамка text box
                Thickness fg = new Thickness(5);
                tew.BorderThickness = fg;
                tew.BorderBrush = Brushes.Chocolate;

                //форму 
                Rect r = new Rect(0, 0, 100, 100);
                tew.Clip = new RectangleGeometry(r,10, 10);

                tew.MinLines = 1;
                tew.MaxLines = 3;
                //возможность переноса текста в строке
                tew.TextWrapping = TextWrapping.Wrap;
                //tew.IsReadOnly = true;
                tew.Text = "комент";
                //позиция на канвасе
                Canvas.SetTop(tew, e.GetPosition(canvas1).Y);
                Canvas.SetLeft(tew, e.GetPosition(canvas1).X);
                //добавляем в коллекцию
                canvas1.Children.Add(tew);

            }
           //рисование возвратной стрелки
            if (line_vozvrat.IsChecked == true)
            {
                //событие с возвратом
                event_return= true;
                str_asinh = false;
                Remove = false;
            }
            //курсор
            if (cu.IsChecked == true)
            {
                Remove=false;
                controlmove = false;
                str_asinh = false;
            }
            //удаление
            if (delete.IsChecked == true)
            {
                str_asinh = false;
                Remove = true;
            }
        }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------перетаскивание элементов-------------------------------------------------------//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        private void canvas1_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            //UIElement line = sender as UIElement;
            //if (line != null)
            //{
            //    Mouse.Capture((UIElement)sender);
            //    Mouse.Capture(null);
              
            //    Canvas.SetTop(((UIElement)sender), e.GetPosition(canvas1).Y);
            //    Canvas.SetLeft(((UIElement)sender), e.GetPosition(canvas1).X);
            //}
            xn = e.GetPosition(canvas1).X;
            //if (scal == false)
            //{
            //    scal = true;
            //}
        }
        private void canvas1_MouseLeftButtonDown_1(object sender, MouseButtonEventArgs e)
        {
          //UIElement line = result.VisualHit as UIElement;
            //if (line != null)
            //{ Mouse.Capture((UIElement)sender); }
            if (Remove == true)
            {
                Point pt = e.GetPosition((Canvas)sender);
                int s=0;
                HitTestResult result = VisualTreeHelper.HitTest((Canvas)sender, pt);
                DependencyObject figura = result.VisualHit;
                DependencyObject io;
                io = VisualTreeHelper.GetParent(result.VisualHit);

                Line l=figura as Line;
                if(l!=null )
                {// индекс линии
                     s=((Canvas)sender).Children.IndexOf(l);
                     if (s > 1)
                     {
                         //получаем стрелку 
                         //если s линия тоs-1 должен быть обьект стрелка
                         line_strelk bn = ((Canvas)sender).Children[s - 1] as line_strelk;
                         if (bn != null)
                         {
                             // ((Canvas)sender).Children[bn.begin_el_n_FC];
                             if (bn.begin_el_n_FC < ((Canvas)sender).Children.Count && bn.end_el_n_FC < ((Canvas)sender).Children.Count)
                             {
                                 life_time rect_B = ((Canvas)sender).Children[bn.begin_el_n_FC] as life_time;
                                 life_time rect_E = ((Canvas)sender).Children[bn.end_el_n_FC] as life_time;
                                 if (rect_B != null && rect_E != null && rect_B.canvasfgh.Children.Count >= bn.begin_el_n_TC && rect_E.canvasfgh.Children.Count >= bn.end_ei_n_TC)
                                 {
                                     delte_strlka_n_I(((Canvas)sender), bn.begin_el_n_TC, bn.end_ei_n_TC, bn.begin_el_n_FC, bn.end_el_n_FC);

                                     //удаление линии
                                     ((Canvas)sender).Children.RemoveAt(s - 1);
                                     //удаление наконечника
                                     ((Canvas)sender).Children.RemoveAt(s - 1);
                                     //удалени обьекта стрелка
                                     ((Canvas)sender).Children.RemoveAt(s - 1);

                                     ((Canvas)sender).Children.RemoveAt(s - 1);

                                     //удаление начального рект
                                     rect_B.canvasfgh.Children.RemoveAt(bn.begin_el_n_TC);
                                     //удаление конечного рект
                                     rect_E.canvasfgh.Children.RemoveAt(bn.end_ei_n_TC);
                                     // delte_strlka_n_I(((Canvas)sender), bn.begin_el_n_TC, bn.end_ei_n_TC, bn.end_el_n_FC);
                                 }
                             }
                         }
                         else
                         { ((Canvas)sender).Children.Remove((UIElement)(((Canvas)sender).InputHitTest(pt))); }
                     }
                    
                }
                Polyline Poly_line = figura as Polyline;
                if (Poly_line != null)
                {// индекс линии
                    s = ((Canvas)sender).Children.IndexOf(Poly_line);
                    if (s > 1)
                    {
                        //получаем стрелку 
                        //если s линия тоs-1 должен быть обьект стрелка c стрелка с возвратом
                        line_str_return bn = ((Canvas)sender).Children[s - 1] as line_str_return;
                        if (bn != null)
                        {
                            if (bn.el_n_FC < ((Canvas)sender).Children.Count)
                            {
                                life_time rect = ((Canvas)sender).Children[bn.el_n_FC] as life_time;
                                if (rect != null && rect.canvasfgh.Children.Count >= bn.el_n_TC)
                                {
                                    delte_strlka_n_return(((Canvas)sender), bn.el_n_TC, bn.el_n_FC);

                                    ((Canvas)sender).Children.RemoveAt(s - 1);

                                    ((Canvas)sender).Children.RemoveAt(s - 1);

                                    rect.canvasfgh.Children.RemoveAt(bn.el_n_TC);
                                    //((Canvas)sender).Children.RemoveAt(s );

                                }
                            }
                        }
                    }
                }
                else
                {
                    ((Canvas)sender).Children.Remove((UIElement)(((Canvas)sender).InputHitTest(pt)));

                }
                    //UIElement df = (UIElement)((Canvas)sender).InputHitTest(pt);
                    // int a=((Canvas)sender).Children.IndexOf(df);
                    // UIElement d = (UIElement)df.InputHitTest(pt);
                  
           
            }
        }
        private void delte_strlka_n_return(Canvas fd, int n_des_E, int count_Lif__FC)
        {
            int Casd = fd.Children.Count;
          //перебираем все стрелки
            for (int j = 0; j < Casd; j++)
            {
                line_strelk bn = fd.Children[j] as line_strelk;
                if (bn != null)
                {
                    //совпадает начало удаляемой lif_time и начало хранимое в стрелке
                    if (count_Lif__FC == bn.begin_el_n_FC)
                    {
                        if (bn.begin_el_n_TC > n_des_E)
                        {
                            bn.begin_el_n_TC--;
                        }
                    }
                    //совпадает начало удаляемой lif_time и конец хранимое в стрелке
                    if (count_Lif__FC == bn.end_el_n_FC)
                    {
                        if (bn.end_ei_n_TC > n_des_E)
                        {
                            bn.end_ei_n_TC--;
                        }

                    }

                } 
                //стрелка с возвратом
                line_str_return str_vozvrat= fd.Children[j] as line_str_return;
                if (str_vozvrat != null)
                {
                    //совпалают линния хизни
                    if (count_Lif__FC == str_vozvrat.el_n_FC)
                    {
                       // индекс удаляемой срелки с возвратом меньше чем найденной
                        if (str_vozvrat.el_n_TC > n_des_E)
                        {
                            str_vozvrat.el_n_TC--;
                        }
                    }

                }
            }     
        }

        /// <summary>
        ///  уменьшение индексов в обьекте стрелка 
        /// </summary>
        /// <param name="fd"> канвас где расположены стрелки </param>
        /// <param name="n_des">ИНДЕКС УДАЛЕННОГО ЭЛЕМЕНТА (рект) начала стрелки</param>
        /// <param name="count_Lif">ИНДЕКС  ЭЛЕМЕНТА (линии жизни из которой удалем рект)</param>
        /// 
    private void delte_strlka_n_I(Canvas fd, int n_des_B, int n_des_E, int count_Lif_begin_FC, int count_Lif_end_FC)
    {
        int Casd = fd.Children.Count;
          //перебираем все стрелки
        for (int j = 0; j < Casd; j++)
        {
             line_strelk bn = fd.Children[j] as line_strelk;
             if (bn != null)
             {
                 //совпадает конец  начало lif_time удаляемого рект со хранимой в стрелке
                 if (count_Lif_begin_FC == bn.begin_el_n_FC && count_Lif_end_FC == bn.end_el_n_FC)
                 {
                     if (bn.begin_el_n_TC > n_des_B && bn.end_ei_n_TC > n_des_E)
                     {
                         bn.begin_el_n_TC--;
                         bn.end_ei_n_TC--;
                     }

                 }
                 else {
                     //совпадает начало удаляемой lif_time и начало хранимое в стрелке
                     if (count_Lif_begin_FC == bn.begin_el_n_FC )
                     {
                         if (bn.begin_el_n_TC > n_des_B)
                         {
                             bn.begin_el_n_TC--;
                         }
                     }
                     //совпадает конец удаляемой lif_time и начало хранимое в стрелке
                     if (count_Lif_end_FC == bn.begin_el_n_FC)
                     {
                         if (bn.begin_el_n_TC > n_des_E)
                         {
                             bn.begin_el_n_TC--;
                         }

                     }
                     //совпадает конец удаляемой lif_time и конец хранимое в стрелке
                     if (count_Lif_end_FC == bn.end_el_n_FC)
                     {
                         if (bn.end_ei_n_TC > n_des_E)
                         {
                             bn.end_ei_n_TC--;
                         }

                     }
                     //совпадает начало удаляемой lif_time и конец хранимое в стрелке
                     if (count_Lif_begin_FC == bn.end_el_n_FC)
                     {
                         if (bn.end_ei_n_TC > n_des_B)
                         {
                             bn.end_ei_n_TC--;
                         }
                     }
                 }

                 ////индекс линии жизни должен совпадать 
                 ////или с  началом стрелки
                 //if (count_Lif == bn.begin_el_n_FC)
                 //{
                 //    //проверяем индекс рект он должен быть больше удаленного рект
                 //    if (bn.begin_el_n_TC > n_des_B)
                 //            //уменьшаем индекс положения рект
                 //            bn.begin_el_n_TC -= 1;
                 //        if (bn.end_ei_n_TC > n_des_E)
                 //            bn.end_ei_n_TC -= 1;
                     
                 //}
                 ////c концом стрелки
                 // if (count_Lif == bn.end_el_n_FC)
                 //{
                 //    //проверяем индекс рект он должен быть больше удаленного рект
                 //    if (bn.begin_el_n_TC > n_des_B)
                 //            //уменьшаем индекс положения рект
                 //            bn.begin_el_n_TC -= 1;
                 //        if (bn.end_ei_n_TC > n_des_E)
                 //            bn.end_ei_n_TC -= 1;
                     
                 //}
  
             }
             //стрелка с возвратом
             line_str_return str_vozvrat = fd.Children[j] as line_str_return;
             if (str_vozvrat != null)
             {
                 //совпалают линния хизни
                 if (count_Lif_end_FC == str_vozvrat.el_n_FC)
                 {
                     // индекс удаляемой срелки с возвратом меньше чем найденной
                     if (str_vozvrat.el_n_TC > n_des_E)
                     {
                         str_vozvrat.el_n_TC--;
                     }
                 }
                 //совпалают линния хизни
                 if (count_Lif_begin_FC == str_vozvrat.el_n_FC)
                 {
                     // индекс удаляемой срелки с возвратом меньше чем найденной
                     if (str_vozvrat.el_n_TC > n_des_B)
                     {
                         str_vozvrat.el_n_TC--;
                     }
                 }

             }

        }
    }
        private void canvas1_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            if (Remove == false)
            {
                Point pt = e.GetPosition((Canvas)sender);

                HitTestResult result = VisualTreeHelper.HitTest((Canvas)sender, pt);
                DependencyObject figura = result.VisualHit;
                DependencyObject io;
                if (result != null)
                {
                    io = VisualTreeHelper.GetParent(result.VisualHit);
                    System.Windows.Controls.TextBox texbox = io as System.Windows.Controls.TextBox;
                    if (texbox != null)
                    {
                        DependencyObject i_o = VisualTreeHelper.GetParent(io);
                        Canvas canva = i_o as Canvas;
                        if (canva != null)
                        {
                            fiure = true;
                            Mouse.Capture((UIElement)io);
                        }
                        else{
                            life_time_capture = true;}
                    }
                    else
                    {
                        //Rectangle as_st = figura as Rectangle;
                        //if (as_st != null)
                        //{
                        //    fiure = true;
                        //    Mouse.Capture((UIElement)figura);

                        //}
                        Ellipse ellipdf = figura as Ellipse;
                        if (ellipdf != null)
                        {
                            fiure = true;
                            Mouse.Capture((UIElement)figura);

                        }
                        Canvas canva = io as Canvas;
                        if (canva != null)
                        {
                            Line lon = figura as Line;
                            if (lon != null)
                            {
                                //если линия захватываем мышь для перетаскивания
                                    linr_ = true;
                                    //находим расстояние от клика до начала и конца линнии 
                                    x1 = Math.Abs(pt.X - lon.X1) * Math.Abs(pt.X - lon.X1) + Math.Abs(pt.Y - lon.Y1) * Math.Abs(pt.Y - lon.Y1);
                                    x2 = Math.Abs(pt.X - lon.X2) * Math.Abs(pt.X - lon.X2) + Math.Abs(pt.Y - lon.Y2) * Math.Abs(pt.Y - lon.Y2);
                                    //выбираем какого конца будем изменять координаты после перетаскивания
                                    if (x1 < x2)
                                    {
                                        point_x1 = true;
                                    }
                                    //((life_time)sender).dro = true;
                                    Mouse.Capture((UIElement)figura);
                            }
                        }
                    }
                }
            }
            else {
                //----------------------------удаление элементов-----------------------------------
                //
                //точка клика
                Point pt = e.GetPosition((Canvas)sender);
                //
                HitTestResult result = VisualTreeHelper.HitTest((Canvas)sender, pt);
                DependencyObject figura = result.VisualHit;
                DependencyObject io;
                if (result != null)
                {
                    //получаем родительский элемент
                    io = VisualTreeHelper.GetParent(result.VisualHit);
                    System.Windows.Controls.TextBox texbox = io as System.Windows.Controls.TextBox;
                    if (texbox != null)
                    {
                        //получаем родительский элемент
                        DependencyObject i_o = VisualTreeHelper.GetParent(io);
                        Canvas canva = i_o as Canvas;
                        if (canva != null)
                        {
                            ((Canvas)sender).Children.Remove((UIElement)io);
                        }
                    }
                }
            }

        }
        /// <summary>
        /// отпускание левой клавиши мыши
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void canvas1_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            if (fiure == true)
            {
                //был выбран элемент

                UIElement figura =( UIElement)Mouse.Captured; 
                if(figura!=null)
                {
                    //задаем позицию захваченному элементу
                    Canvas.SetTop(((UIElement)figura), e.GetPosition(canvas1).Y);
                    Canvas.SetLeft(((UIElement)figura), e.GetPosition(canvas1).X);
                    Mouse.Capture(null);
                    fiure = false;
                }
            }
            
            if (linr_ == true)
            {
                //была захвачена линия
                linr_ = false;
                UIElement figura = (UIElement)Mouse.Captured;
                if (figura != null)
                {
                    if (point_x1 == true)
                    {//была выбрана начальная точка линии
                        ((Line)figura).X1 = e.GetPosition(canvas1).X;
                        ((Line)figura).Y1= e.GetPosition(canvas1).Y;
                        point_x1 = false;
                    }
                    else
                    {
                        //была выбрана конечная точка линии
                        ((Line)figura).X2=e.GetPosition(canvas1).X;
                        ((Line)figura).Y2 = e.GetPosition(canvas1).Y;
                    }
                    Mouse.Capture(null);
                }
            }
        }
        private void life_t_PreviewMouseDown(object sender, MouseButtonEventArgs e)
        {

            Rectangle rest2=new Rectangle();
            Rectangle rest1=new Rectangle();

            if (life_time_capture == true)
            {
                X_0 =  Canvas.GetLeft (((life_time)sender));;
                Mouse.Capture((life_time)sender);
            }

            Point pt = e.GetPosition(canvas1);
            HitTestResult result = VisualTreeHelper.HitTest(canvas1, pt);
            DependencyObject io;
            io = VisualTreeHelper.GetParent(result.VisualHit);
            DependencyObject i;
            i = VisualTreeHelper.GetParent(io);
            if (result != null)
            {
                Line lon = result.VisualHit as Line;
                if (lon != null)
                {
                    //рисуем два события и стрелку
                    if (str_asinh == true)
                    {

                        ////////////////////////////////////////////рисуем стрелку с линией времени////////////////////////////////////////////////

                        ((life_time)sender).dro = false;
                        if (numb == 1)
                        {
                            ((life_time)sender).new_Rect(0);

                            //-----------------позиция начала стрелки 
                            li_ = new line_strelk();
                            //запоминаем Y2 для линии
                            line_Y2 = e.GetPosition((canvas1)).Y;
                            //начало линии
                            li_.pos_line_B(new Point(e.GetPosition((canvas1)).X + 10, line_Y2));
                            //проперти линии
                            li_.line_prop_();
                            //запоминаем номер в коллекции рект 1 начало стрелки 
                            li_.begin_el_n_FC = ((life_time)sender).n_child;

                            //запоминаем номер в коллекции рект 1 начало стрелки 
                            li_.begin_el_n_TC = (((Canvas)i).Children.Count);
                            // добавляем в коллекцию рект 1 начало стрелки 
                            //((Canvas)i).Children.Add(rest1);
                            ((life_time)sender).add_rect_canvac(Canvas.GetLeft((life_time)sender), e.GetPosition(((Canvas)i)).Y);
                            //добавляем координаты второго рект
                            rect_2_Y = e.GetPosition(((Canvas)i)).Y;
                            numb--;
                        }
                        else
                        {
                            //-----------------позиция конца стрелки
                            //list_strelka.Add(li_);
                            li_.pos_line_E_X2(e.GetPosition(canvas1).X - 10);
                            li_.pos_line_E_Y2(line_Y2);

                            //запоминаем номер линии жизни на
                            li_.end_el_n_FC = ((life_time)sender).n_child;

                            ////-----------------рисуем второй рект

                            ((life_time)sender).new_Rect(0);

                            //добавлем обект стрелка

                            canvas1.Children.Add(li_);
                            //добавляем линию и наконечник
                            li_.add_canvas(canvas1);

                            //запоминаем номер в коллекции рект 2 конец стрелки 
                            li_.end_ei_n_TC = (((Canvas)i).Children.Count);

                            // добавляем в коллекцию рект 2 конец стрелк
                            //((Canvas)i).Children.Add(rest2);
                            ((life_time)sender).add_rect_canvac(e.GetPosition(((Canvas)i)).X - 10, rect_2_Y);

                            //разрешаем перетаскивание линию -линии жизни 2
                            //((life_time)sender).dro = true;
                            numb = 1;

                        }
                    }
/////////////////////////////////////////////////рисуем стрелку с линией времени////////////////////////////////////////////////

                 

                  
//////////////////////////////////////////////рисуем событие с возвратом//////////////////////////////////////////////
                    if (event_return == true)
                    {
                        //разрешаем  увелечение  линии жизни
                        ((life_time)sender).dro = false;

                        ((life_time)sender).new_Rect(0);
                        //возваратная стрелка
                        line_str_return str_ret=new line_str_return();
                        str_ret.numb_l_t_in_canvas = ((life_time)sender).n_child;

                        str_ret.line_prop_str_return(e.GetPosition((canvas1)).X+10,e.GetPosition((canvas1)).Y);

                        str_ret.el_n_TC = (((Canvas)i).Children.Count);

                        ((life_time)sender).add_rect_canvac(Canvas.GetLeft((life_time)sender), e.GetPosition(((Canvas)i)).Y);

                        str_ret.el_n_FC=((life_time)sender).n_child;

                     

                        //добавление обекта  стрелки с возвратом на главный канвас
                        canvas1.Children.Add(str_ret);
                        //добавление   стрелки с возвратом на главный канвас
                        str_ret.add_canvas(canvas1);
                    }
//////////////////////////////////////////////рисуем событие с возвратом//////////////////////////////////////////////
                        
                    if(event_return==false && str_asinh==false)
                     {((life_time)sender).dro = true; }
                }
            }
            if (Remove == true)
            {
                life_time delete_l_time=(life_time)sender as life_time;

                if (delete_l_time != null)
                {
                    int f = 0;
                    int Casd = canvas1.Children.Count;
                    //перебираем все стрелки
                    for (int j = Casd-1; j >0; j--)
                    {
                        line_strelk bn = canvas1.Children[j] as line_strelk;
                        if (bn != null)
                        {

                            life_time rect_B = canvas1.Children[bn.begin_el_n_FC] as life_time;
                            life_time rect_E = canvas1.Children[bn.end_el_n_FC] as life_time;

                            //совпадает начало удаляемой lif_time и начало хранимое в стрелке
                            if (delete_l_time.n_child == bn.begin_el_n_FC||delete_l_time.n_child == bn.end_el_n_FC)
                            {
                                delte_strlka_n_I(canvas1, bn.begin_el_n_TC, bn.end_ei_n_TC, bn.begin_el_n_FC, bn.end_el_n_FC);

                                //удаление линии
                                canvas1.Children.RemoveAt(j );
                                //удаление наконечника
                                canvas1.Children.RemoveAt(j );
                                //удалени обьекта стрелка
                                canvas1.Children.RemoveAt(j );

                               canvas1.Children.RemoveAt(j );
                              //  Casd -= 4;

                               //удаление начального рект
                               rect_B.canvasfgh.Children.RemoveAt(bn.begin_el_n_TC);
                               //удаление конечного рект
                               rect_E.canvasfgh.Children.RemoveAt(bn.end_ei_n_TC);

                               

                        
                                j--;
                            }
                        }
                        //получаем стрелку 
                        //если s линия тоs-1 должен быть обьект стрелка c стрелка с возвратом
                        line_str_return del_v_str = canvas1.Children[j] as line_str_return;
                        if (del_v_str != null)
                        {
                            if (del_v_str.el_n_FC < (canvas1.Children.Count))
                            {
                                life_time rect = canvas1.Children[del_v_str.el_n_FC] as life_time;
                                if (delete_l_time.n_child == del_v_str.el_n_FC)
                                {
                                    delte_strlka_n_return(canvas1, del_v_str.el_n_TC, del_v_str.el_n_FC);

                                    canvas1.Children.RemoveAt(j);
                                    canvas1.Children.RemoveAt(j);

                                   // Casd -= 2;
                                    //((Canvas)sender).Children.RemoveAt(s );
                                    rect.canvasfgh.Children.RemoveAt(del_v_str.el_n_TC);

                                  
                               
                                }
                            }
                        }
                    }
                    dec_life_time(delete_l_time.n_child);

                    canvas1.Children.Remove(delete_l_time);
                      //уменьшение индекса n_child
               
                }
                else
                {
                    canvas1.Children.Remove((UIElement)sender);
                }
                
            }
        }
        private void dec_life_time(int index_life_time_del)
        {
               int Casd = canvas1.Children.Count;
                    //перебираем все стрелки
               for (int j = Casd - 1; j > 0; j--)
               {
                   life_time bn = canvas1.Children[j] as life_time;
                   if (bn != null)
                   {
                       if (bn.n_child > index_life_time_del)
                       {
                           bn.n_child--;

                       }
                   }
                  line_str_return del_v_str = canvas1.Children[j] as line_str_return;
                  if (del_v_str != null)
                  {
                      if (del_v_str.el_n_FC > index_life_time_del)
                      {
                          del_v_str.el_n_FC--;
                      }
                  }
                  line_strelk del_str = canvas1.Children[j] as line_strelk;
                  if (del_str != null)
                  {
                      if (del_str.begin_el_n_FC > index_life_time_del)
                      {
                          del_str.begin_el_n_FC--;
                      }
                      if (del_str.end_ei_n_TC > index_life_time_del)
                      {
                          del_str.end_ei_n_TC--;
                      }
                  }

               }
        }
        private void life_t_PreviewMouseLeftButtonUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
        {
            if (life_time_capture == true)
            {
                life_time_capture = false;
                life_time line = sender as life_time;
                if (line != null)
                {
                    Canvas.SetTop(((life_time)sender), 20);
                    Canvas.SetLeft(((life_time)sender), e.GetPosition(canvas1).X);

                    Mouse.Capture(null);
                   // VisualCollection df = new VisualCollection();
                    int Casd = canvas1.Children.Count;
                    for (int j = 0; j < Casd; j++)
                    {
                        line_strelk l1 = canvas1.Children[j] as line_strelk;
                           if (l1 != null)
                           {
                             //находим принадлежащие  линии Жизни
                                if (l1.begin_el_n_FC == ((life_time)sender).n_child)
                                {
                                    //передвигаем начало стрелки
                                    double delta = l1.strelka.X1 - X_0;
                                    l1.pos_line_B_X1(delta + e.GetPosition(canvas1).X);
                                }
                                if (l1.end_el_n_FC== ((life_time)sender).n_child)
                                {
                                    //передвигаем  конец
                                    double delta = l1.strelka.X2 - X_0;
                                    l1.pos_line_E_X2(delta + e.GetPosition(canvas1).X);
                                }
                           }
                           line_str_return l_return = canvas1.Children[j] as line_str_return;

                          //перерисовываем стрелку с возвратом
                           if (l_return != null)
                           {
                               if (l_return.numb_l_t_in_canvas == ((life_time)sender).n_child)
                               {
                                   PointCollection asd = l_return.str_return.Points;
                                   Point Begin_point = asd[0];
                                   double delta = Begin_point.X - X_0;
                                   l_return.line_prop_str_return(delta + e.GetPosition(canvas1).X, Begin_point.Y);
                               }
                           }
                        //опред области попадания
                        Line l=canvas1.Children[j] as Line;
                        if (l != null)
                        {

                            //int h = list_strelka.Count;
                            
                            //for (int i = 0; i < h; i++)

                            //{
                            //    if (j == list_strelka[i].N)
                            //    {
                            //        if(list_strelka[i].begin_el_n_FC==)
                            //        {

                            //        }

                            //    }
                            //}

                            //    if (((Line)canvas1.Children[j]).X2 > X_0 && ((Line)canvas1.Children[j]).X2 < X_0 + 60)
                            //    {
                            //        double delta = ((Line)canvas1.Children[j]).X2 - X_0;
                            //        ((Line)canvas1.Children[j]).X2 = delta + e.GetPosition(canvas1).X;
                            //    }
                            //if (((Line)canvas1.Children[j]).X1 > X_0 + 60 && ((Line)canvas1.Children[j]).X1 < X_0 + 120)
                            //{
                            //    double delta = ((Line)canvas1.Children[j]).X1 - X_0;
                            //    ((Line)canvas1.Children[j]).X1 = delta + e.GetPosition(canvas1).X;
                            //}
 
                        }
                        
                    }
                }

                //if (controlmove)
                //{
                //    System.Windows.Input.Mouse.Capture(null);
                //}
            }
        }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//----------------------------------------------перетаскивание элементов-------------------------------------------------------//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 
            private void ellip_MouseLeave(object sender, System.Windows.Input.MouseEventArgs e)

        {
            Ellipse df = (Ellipse)sender;
            df.Fill = Brushes.Red;

        }
        //техблок
            private void tew_MouseDoubleClick(object sender, System.Windows.Input.MouseEventArgs e)
            {
             // ( (System.Windows.Controls.TextBox)sender).IsReadOnly = false;

              
               

            }
            private void tew_MouseEnter(object sender, System.Windows.Input.MouseEventArgs e)
            {

                //
             //((System.Windows.Controls.TextBox)sender).Height = ((System.Windows.Controls.TextBox)sender).ActualHeight;

                //Canvas.SetTop(vvt, e.GetPosition(canvas1).Y);
                //Canvas.SetLeft(vvt, e.GetPosition(canvas1).X);
                //canvas1.Children.Add(vvt);
                

            }
        private void tew_MouseLeave(object sender, System.Windows.Input.MouseEventArgs e)
        {

            // ((System.Windows.Controls.TextBox)sender).IsReadOnly = true;
        }
        private void ellip_MouseEnter(object sender, System.Windows.Input.MouseEventArgs e)
        {
            Ellipse df = (Ellipse)sender;
            df.Fill = Brushes.Beige;

        }
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            redacto =true;

        }
        private void cmdSelectMove_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            //scal = false;
        }
        private void cmdSelectMove_Click(object sender, RoutedEventArgs e)
        {

            numb = 1;
        }
        //private void canvas1_MouseMove(object sender, MouseEventArgs e)
        //{
        //    Ellipse asd=new Ellipse();
        //    if (asd == sender)
        //        asd = (Ellipse)sender;


        //    asd.Width = Math.Abs(xn - e.GetPosition(canvas1).X);

       // }
        private void new_prog_Click(object sender, RoutedEventArgs e)
        {

            DialogResult dr;
           // if (figures.Count > 0)
           // {
                dr = System.Windows.Forms.MessageBox.Show( "Do you wish to save the current Diagram?",
                  "Before Creating a new Diagram...", MessageBoxButtons.YesNoCancel);
                if (dr == System.Windows.Forms.DialogResult.Cancel) return;
                if (dr == System.Windows.Forms.DialogResult.Yes) 
                {
                    SaveFileDialog SaveFileDialog1 = new SaveFileDialog();

                    SaveFileDialog1.Filter = "files (*.avg)|*.avg";
                    SaveFileDialog1.RestoreDirectory = true;

                    if (SaveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        try
                        {
                            SaveDiagram(SaveFileDialog1.FileName);
                        }
                        catch (Exception ex)
                        {
                            System.Windows.Forms.MessageBox.Show("Error: Could not read file from disk. Original error: " + ex.Message);
                        }
                    } 
                };
            //}
            //ClearDiagram();

                canvas1.Children.Clear();

        }

       
        void OnMouseEnterHandler(object sender, System.Windows.Input.MouseEventArgs e)
        {
            el = new Ellipse();
            el = (Ellipse)sender;
            el.Fill = Brushes.Bisque;
        }

        public double xn { get; set; }

        public IWin32Window thi { get; set; }

        public Ellipse el { get; set; }

        private void life_t_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
           // a.Focus();
            //s = a.;
        }

        private void life_t_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
        {
            //if (controlmove)
            //{
            //    A1 = sender as life_time;

            //    //System.Drawing.Size s0 = new System.Drawing.Size((int)(e.GetPosition(canvas1).X - p.X), (int)(e.GetPosition(canvas1).Y - p.Y));
            //    if (e.LeftButton == MouseButtonState.Pressed)
            //    {

            //        Canvas.SetTop(A1, (e.GetPosition(canvas1).Y - p.X));
            //        Canvas.SetLeft(A1, (e.GetPosition(canvas1).X - p.Y));
            //    }
            //}  
        }
        private void Window_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
        {
        }
        private void grid1_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
        {  
        }
        private void canvas1_MouseMove(object sender, System.Windows.Input.MouseEventArgs e)
        {
        }

        private void delete_Click(object sender, RoutedEventArgs e)
        {
            Remove = true;
            event_return = false;
            str_asinh = false;
        }
        private void li_str_Click(object sender, RoutedEventArgs e)
        {
            Remove = false;
            str_asinh = true;
            numb = 1;
            event_return = false;
        }
        private void cu_Checked(object sender, RoutedEventArgs e)
        {
            str_asinh = false;
            event_return = false;
            Remove = false;
        }
        //возвратная стрелка
        private void line_vozvrat_Click(object sender, RoutedEventArgs e)
        {
            event_return = true;
            str_asinh = false;
            Remove = false;
        }
        
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//---------------------------сохранение и загрузка---------------------------------------------------------------//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     
        private void MenuItem_Click(object sender, RoutedEventArgs e)
        {
            StreamWriter sr;
            SaveFileDialog SaveFileDialog1 = new SaveFileDialog();

            SaveFileDialog1.Filter = "files (*.avg)|*.avg|files (*.)|*.*";
       
            SaveFileDialog1.RestoreDirectory = true;

            if (SaveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                try
                {
                    SaveDiagram(SaveFileDialog1.FileName);
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show("Error: Could not read file from disk. Original error: " + ex.Message);
                }
            } 
           
        }
        private void MenuItem_Click_1(object sender, RoutedEventArgs e)
        {
            OpenFileDialog openFileDialog1 = new OpenFileDialog();

            //openFileDialog1.Filter = "txt files (*.txt)|*.txt";
            openFileDialog1.RestoreDirectory = true;
            openFileDialog1.Filter = "files (*.avg)|*.avg|files (*.)|*.*";
            if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                try
                {
                    LoadFile(openFileDialog1.FileName);
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show("Error: Could not read file from disk. Original error: " + ex.Message);
                }
            }
           
        }

        private void LoadFile(string name_F)
        {
            //System.IO.MemoryStream stream = new System.IO.MemoryStream();


            canvas1.Children.Clear();
            //FileStream fs = File.OpenRead("qwerty.xml");



            Line Lining;
            line_strelk li_;
            life_time new_;
            Save Sav_ = new Save();
            Sav_.load_all(name_F);

            int count = Sav_.List_L_T.Count;
            for (int i = 0; i < count; i++)
            {
                new_ = new life_time();
                new_.PreviewMouseDown += new MouseButtonEventHandler(life_t_PreviewMouseDown);
                new_.PreviewMouseLeftButtonUp += new MouseButtonEventHandler(life_t_PreviewMouseLeftButtonUp);

                int count_rect = Sav_.List_L_T[i].rect_List.Count;
                for (int j = 0; j < count_rect; j++ )
                {

                    if (Sav_.List_L_T[i].rect_List[j].Hight != 50)
                    {
                        new_.new_Rect(0);
                    }
                    else {
                        new_.new_Rect(Sav_.List_L_T[i].rect_List[j].Hight);
                    }
                
                    new_.add_rect_canvac(Sav_.List_L_T[i].rect_List[j].Set_top,Sav_.List_L_T[i].rect_List[j].Set_top);
                   // Rect.Height= Sav_.List_L_T[i].rect_List[j].Hight;
                    //Canvas.SetTop(Rect, );
                    //Canvas.SetLeft(Rect, Sav_.List_L_T[i].rect_List[j].Set_left);
                   // new_.canvasfgh.Children.Add(Rect);
                }

            
                new_.text_box.Text = Sav_.List_L_T[i].text;
                new_._line.Y2 = Sav_.List_L_T[i].Line_Y;
                Canvas.SetLeft(new_, Sav_.List_L_T[i].set_left);
                Canvas.SetTop(new_, Sav_.List_L_T[i].Set_top);

                new_.n_child = canvas1.Children.Count;
                canvas1.Children.Add(new_);
                
            }
            //отображаем все стрелки
            int count_strel = Sav_.List_strelca.Count;
            for (int z = 0; z < count_strel; z++)
            {
                li_ = new line_strelk();
                //инилизация 
                li_.line_prop_();
                //заполняем свойства зависимости
                li_.begin_el_n_FC = Sav_.List_strelca[z].begin_el_n_FC;
                li_.begin_el_n_TC = Sav_.List_strelca[z].begin_el_n_TC;
                li_.end_ei_n_TC = Sav_.List_strelca[z].end_ei_n_TC;
                li_.end_el_n_FC = Sav_.List_strelca[z].end_el_n_FC;
                //положение
                li_.strelka.X1 = Sav_.List_strelca[z].X1;
                li_.strelka.X2 = Sav_.List_strelca[z].X2;
                li_.strelka.Y1= Sav_.List_strelca[z].Y12;
                li_.strelka.Y2=Sav_.List_strelca[z].Y12;

                //добавление на канвас
                canvas1.Children.Add(li_);
                //добавляем линию и наконечник
                li_.add_canvas(canvas1);
            }
            int count_coment = Sav_.List_textbox.Count;
            for (int k = 0; k < count_coment; k++)
            {
                
                tew = new System.Windows.Controls.TextBox();
                Thickness bp = new Thickness(5);
                tew.BorderThickness = bp;
                tew.BorderBrush = Brushes.Chocolate;
                tew.Text = Sav_.List_textbox[k].Texts;
                Canvas.SetLeft(tew, Sav_.List_textbox[k].Set_left);
                Canvas.SetTop(tew, Sav_.List_textbox[k].Set_top);
                canvas1.Children.Add(tew);
            }
            int count_lineshape = Sav_.List_liner.Count;
            for (int fu=0; fu < count_lineshape; fu++)
            {
                Lining = new Line();
                Lining.StrokeEndLineCap = PenLineCap.Triangle;  //задает наконечник
                Lining.Stroke = Brushes.Black;                   //способ закраски контура fill не исполь solicolorbrash

                Lining.StrokeMiterLimit = 10;
                DoubleCollection D_C_l = new DoubleCollection(2);
                D_C_l.Add(4);
                D_C_l.Add(2);
                Lining.StrokeDashArray = D_C_l;                  //задает пунктир
                Lining.StrokeThickness = 2;    
                Lining.X1 = Sav_.List_liner[fu].X1;
                Lining.X2 = Sav_.List_liner[fu].X2;
                Lining.Y1 = Sav_.List_liner[fu].Y1;
                Lining.Y2 = Sav_.List_liner[fu].Y2;
                canvas1.Children.Add(Lining);
                
            }

        }
        private void SaveDiagram(string name_F)
        {

            Save Sav_ = new Save();
            Line serch_line;
            life_time L_T_searce ;
            line_strelk L_Strelka_Searh;
            life_t L_T;
            System.Windows.Controls.TextBox text_serce;
            int count;
            count = canvas1.Children.Count;
           //перебираем все элементы
            for (int i=0; i < count; i++ )
            {
                L_T_searce = new life_time();
                L_T_searce = canvas1.Children[i] as life_time;
                if (L_T_searce != null)
                {
                    L_T = new editor.life_t();
                    int coun_rect = L_T_searce.canvasfgh.Children.Count;
                    for (int j = 0; j < coun_rect; j++)
                    {
                        Rectangle R_T = L_T_searce.canvasfgh.Children[j] as Rectangle;
                        if (R_T != null)
                        {
                            // сохранение всех события
                            Rectan Rec_ = new Rectan();
                            Rec_.Set_top = Canvas.GetTop(R_T);
                            Rec_.Set_left = Canvas.GetLeft(R_T);
                            Rec_.Hight = R_T.Height;
                            // добавление события в rect_List хронящийся в линиии жизни
                            L_T.rect_List.Add(Rec_);   //

                        }
                    }
                    // сохранение характеристик life_time

                    L_T.set_left = Canvas.GetLeft(L_T_searce);
                    L_T.Set_top = Canvas.GetTop(L_T_searce);
                    L_T.save_life_t(L_T_searce.text_box.Text, L_T_searce._line.Y2);
                    // добавление в List_L_T хронящися в классе Save
                    Sav_.List_L_T.Add(L_T);
                }
                //находим стрелку
                L_Strelka_Searh = new line_strelk();
                L_Strelka_Searh = canvas1.Children[i] as line_strelk;
                if (L_Strelka_Searh != null)
                {
                    //сохранение стрелки в обьект класса save
                    strelca srtelca = new strelca();
                    //свойства зависимости 
                    srtelca.begin_el_n_FC = L_Strelka_Searh.begin_el_n_FC;
                    srtelca.begin_el_n_TC = L_Strelka_Searh.begin_el_n_TC;
                    srtelca.end_ei_n_TC=L_Strelka_Searh.end_ei_n_TC;
                    srtelca.end_el_n_FC = L_Strelka_Searh.end_el_n_FC;
                    //положение
                    srtelca.X1 = L_Strelka_Searh.strelka.X1;
                    srtelca.X2 = L_Strelka_Searh.strelka.X2;
                    srtelca.Y12 = L_Strelka_Searh.strelka.Y1;
                    //добавление
                    Sav_.List_strelca.Add(srtelca);
                    break;
                }
                text_serce = new System.Windows.Controls.TextBox();
                text_serce = canvas1.Children[i] as System.Windows.Controls.TextBox;
                if (text_serce != null)
                {
                    // сохранение коментария в объект класса save
                    Textboxs text_boxes = new Textboxs();
                    text_boxes.Set_top = Canvas.GetTop(text_serce);
                    text_boxes.Set_left = Canvas.GetLeft(text_serce);
                    text_boxes.Texts = text_serce.Text;
                    // добавление
                    Sav_.List_textbox.Add(text_boxes);
                }
                serch_line = new Line();
                serch_line = canvas1.Children[i] as Line;
                if (serch_line != null)
                {
                    // сохранение штрихованной лини в объект класса save
                    Liner liner_shape = new Liner();
                    liner_shape.X1 = serch_line.X1;
                    liner_shape.X2 = serch_line.X2;
                    liner_shape.Y1 = serch_line.Y1;
                    liner_shape.Y2 = serch_line.Y2;
                    // добавление
                    Sav_.List_liner.Add(liner_shape);
                }
            }
            Sav_.save_all(name_F);  
        }
        //сохранение в картинку
        public static void SaveCanvasToFile(Canvas surface, string filename)
        {
            Size size = new Size(surface.Width, surface.Height);

            surface.Measure(size);
            surface.Arrange(new Rect(size));

            // Create a render bitmap and push the surface to it
            RenderTargetBitmap renderBitmap =
              new RenderTargetBitmap(
                (int)size.Width,
                (int)size.Height,
                96d,
                96d,
                PixelFormats.Pbgra32);
            renderBitmap.Render(surface);

            // Create a file stream for saving image
            using (FileStream outStream = new FileStream(filename, FileMode.Create))
            {
                BmpBitmapEncoder encoder = new BmpBitmapEncoder();
                // push the rendered bitmap to it
                encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
                // save the data to the stream
                encoder.Save(outStream);
            }
        }

        private void MenuItem_Click_2(object sender, RoutedEventArgs e)
        {
         
            SaveFileDialog SaveFileDialog1 = new SaveFileDialog();

            //SaveFileDialog1.Filter = "txt files (*.txt)|*.txt";
            SaveFileDialog1.RestoreDirectory = true;
           

            if (SaveFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                try
                {
                    SaveCanvasToFile(canvas1, SaveFileDialog1.FileName);
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show("Error: Could not read file from disk. Original error: " + ex.Message);
                }
            } 
           //SaveWindow(this, 96, "window.png");
           //SaveCanvas_2(this, canvas1, 96, "window.png");
        }
        public static void SaveWindow(Window window, int dpi, string filename)
        {

            var rtb = new RenderTargetBitmap(
                (int)window.Width, //width
                (int)window.Width, //height
                dpi, //dpi x
                dpi, //dpi y
                PixelFormats.Pbgra32 // pixelformat
                );
            rtb.Render(window);

            SaveRTBAsPNG(rtb, filename);

        }
        private static void SaveRTBAsPNG(RenderTargetBitmap bmp, string filename)
        {
            var enc = new System.Windows.Media.Imaging.PngBitmapEncoder();
            enc.Frames.Add(System.Windows.Media.Imaging.BitmapFrame.Create(bmp));

            using (var stm = System.IO.File.Create(filename))
            {
                enc.Save(stm);
            }
        }
        public static void SaveCanvas_2(Window window, Canvas canvas, int dpi, string filename)
        {
            Size size = new Size(window.Width, window.Height);
            canvas.Measure(size);
            //canvas.Arrange(new Rect(size));

            var rtb = new RenderTargetBitmap(
                (int)window.Width, //width
                (int)window.Height, //height
                dpi, //dpi x
                dpi, //dpi y
                PixelFormats.Pbgra32 // pixelformat
                );
            rtb.Render(canvas);

            SaveRTBAsPNG(rtb, filename);
        }
       //перейти на шаг вперед
        private void button2_Click(object sender, RoutedEventArgs e)
        {

            if (tekuhee_load <count_save && tekuhee_load >= 0)
            {
                canvas1.Children.Clear();
                //переходим к файлу на шаг позже
               // tekuhee_load = count_save;
                tekuhee_load++;
                LoadFile(save_undo_rendo + tekuhee_load);

            }
           

        }
        //перейти на шаг назад
        private void button1_Click_1(object sender, RoutedEventArgs e)
        {
            if(tekuhee_load<=count_save&&tekuhee_load>0)
            {
                canvas1.Children.Clear();
                //переходим к файлу на шаг раньше
               
                tekuhee_load--;
                LoadFile(save_undo_rendo + tekuhee_load);
            }
        }

        private void Window_MouseWheel(object sender, MouseWheelEventArgs e)
        {
                   
                if (System.Windows.Input.Keyboard.IsKeyDown(Key.Z))
                {
                   

                    if (e.Delta == 120)
                    {
                           if(zoom<1.5)
                           {
                        canvas1.RenderTransform = new ScaleTransform(zoom, zoom);
                               zoom+=0.1;
                           }

                    }
                    if (e.Delta == -120)
                    {
                        if (zoom > 0.5)
                        {
                            canvas1.RenderTransform = new ScaleTransform(zoom, zoom);
                            zoom -= 0.1;
                        }
                    }
                    
                     textBlock1.Text=zoom.ToString();
                

                    
                }

            

        }
    
      

       

   
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//---------------------------сохранение и загрузка---------------------------------------------------------------//
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

     
    }
}
